package com.kexilo.messaging.service;

import com.kexilo.messaging.domain.Message;
import java.util.List;
import java.util.Map;
import java.util.concurrent.CompletableFuture;

/**
 * 消息服务接口
 * 定义了消息处理的抽象接口，不依赖任何具体实现
 * 
 * @author Kexilo
 */
public interface MessageService {
    
    /**
     * 发送消息
     * 
     * @param message 消息对象
     * @return 发送结果
     */
    boolean sendMessage(Message message);
    
    /**
     * 异步发送消息
     * 
     * @param message 消息对象
     * @return 异步发送结果
     */
    CompletableFuture<Boolean> sendMessageAsync(Message message);
    
    /**
     * 批量发送消息
     * 
     * @param messages 消息列表
     * @return 成功发送的数量
     */
    int batchSendMessages(List<Message> messages);
    
    /**
     * 发送延迟消息
     * 
     * @param message 消息对象
     * @param delayMillis 延迟时间（毫秒）
     * @return 发送结果
     */
    boolean sendDelayMessage(Message message, long delayMillis);
    
    /**
     * 发送定时消息
     * 
     * @param message 消息对象
     * @param timestamp 定时时间戳
     * @return 发送结果
     */
    boolean sendScheduledMessage(Message message, long timestamp);
    
    /**
     * 订阅消息
     * 
     * @param topic 主题
     * @param processor 消息处理器
     * @return 订阅结果
     */
    boolean subscribe(String topic, MessageProcessor processor);
    
    /**
     * 取消订阅
     * 
     * @param topic 主题
     * @return 取消结果
     */
    boolean unsubscribe(String topic);
    
    /**
     * 拉取消息
     * 
     * @param topic 主题
     * @param maxMessages 最大消息数
     * @return 消息列表
     */
    List<Message> pullMessages(String topic, int maxMessages);
    
    /**
     * 确认消息处理
     * 
     * @param messageId 消息ID
     * @return 确认结果
     */
    boolean acknowledgeMessage(String messageId);
    
    /**
     * 拒绝消息
     * 
     * @param messageId 消息ID
     * @param requeue 是否重新入队
     * @return 拒绝结果
     */
    boolean rejectMessage(String messageId, boolean requeue);
    
    /**
     * 根据消息ID查询消息
     * 
     * @param messageId 消息ID
     * @return 消息对象
     */
    Message getMessageById(String messageId);
    
    /**
     * 根据业务ID查询消息
     * 
     * @param businessId 业务ID
     * @return 消息列表
     */
    List<Message> getMessagesByBusinessId(String businessId);
    
    /**
     * 根据状态查询消息
     * 
     * @param status 消息状态
     * @param limit 限制数量
     * @return 消息列表
     */
    List<Message> getMessagesByStatus(Message.MessageStatus status, int limit);
    
    /**
     * 重试失败消息
     * 
     * @param messageId 消息ID
     * @return 重试结果
     */
    boolean retryMessage(String messageId);
    
    /**
     * 批量重试消息
     * 
     * @param messageIds 消息ID列表
     * @return 成功重试的数量
     */
    int batchRetryMessages(List<String> messageIds);
    
    /**
     * 删除消息
     * 
     * @param messageId 消息ID
     * @return 删除结果
     */
    boolean deleteMessage(String messageId);
    
    /**
     * 清理过期消息
     * 
     * @param daysBeforeNow 多少天之前
     * @return 清理的数量
     */
    int cleanupExpiredMessages(int daysBeforeNow);
    
    /**
     * 获取死信队列消息
     * 
     * @param topic 主题
     * @param limit 限制数量
     * @return 死信消息列表
     */
    List<Message> getDeadLetterMessages(String topic, int limit);
    
    /**
     * 处理死信消息
     * 
     * @param messageId 消息ID
     * @param action 处理动作（RETRY, DELETE, IGNORE等）
     * @return 处理结果
     */
    boolean handleDeadLetterMessage(String messageId, String action);
    
    /**
     * 获取消息统计信息
     * 
     * @return 统计信息
     */
    Map<String, Object> getMessageStatistics();
    
    /**
     * 获取主题统计信息
     * 
     * @param topic 主题
     * @return 主题统计信息
     */
    Map<String, Object> getTopicStatistics(String topic);
    
    /**
     * 获取消息趋势数据
     * 
     * @param topic 主题
     * @param hours 统计小时数
     * @return 趋势数据
     */
    List<Map<String, Object>> getMessageTrends(String topic, int hours);
    
    /**
     * 暂停消息消费
     * 
     * @param topic 主题
     * @return 暂停结果
     */
    boolean pauseConsumer(String topic);
    
    /**
     * 恢复消息消费
     * 
     * @param topic 主题
     * @return 恢复结果
     */
    boolean resumeConsumer(String topic);
    
    /**
     * 检查消费者状态
     * 
     * @param topic 主题
     * @return 消费者状态
     */
    String getConsumerStatus(String topic);
    
    /**
     * 创建主题
     * 
     * @param topic 主题名称
     * @param partitions 分区数
     * @param replicas 副本数
     * @return 创建结果
     */
    boolean createTopic(String topic, int partitions, int replicas);
    
    /**
     * 删除主题
     * 
     * @param topic 主题名称
     * @return 删除结果
     */
    boolean deleteTopic(String topic);
    
    /**
     * 获取所有主题
     * 
     * @return 主题列表
     */
    List<String> getAllTopics();
    
    /**
     * 导出消息
     * 
     * @param topic 主题
     * @param startTime 开始时间
     * @param endTime 结束时间
     * @param format 导出格式
     * @return 导出文件路径
     */
    String exportMessages(String topic, String startTime, String endTime, String format);
    
    /**
     * 检查服务是否可用
     * 
     * @return 是否可用
     */
    boolean isAvailable();
    
    /**
     * 获取服务健康状态
     * 
     * @return 健康状态信息
     */
    Map<String, Object> getHealthStatus();
    
    /**
     * 获取服务名称
     * 
     * @return 服务名称
     */
    default String getServiceName() {
        return this.getClass().getSimpleName();
    }
    
    /**
     * 获取服务版本
     * 
     * @return 服务版本
     */
    default String getServiceVersion() {
        return "1.0.0";
    }
    
    /**
     * 消息处理器接口
     */
    @FunctionalInterface
    interface MessageProcessor {
        /**
         * 处理消息
         * 
         * @param message 消息对象
         * @return 处理结果
         */
        ProcessResult process(Message message);
    }
    
    /**
     * 消息拦截器接口
     */
    interface MessageInterceptor {
        /**
         * 发送前拦截
         * 
         * @param message 消息对象
         * @return 是否继续处理
         */
        default boolean beforeSend(Message message) {
            return true;
        }
        
        /**
         * 发送后拦截
         * 
         * @param message 消息对象
         * @param success 发送结果
         */
        default void afterSend(Message message, boolean success) {}
        
        /**
         * 处理前拦截
         * 
         * @param message 消息对象
         * @return 是否继续处理
         */
        default boolean beforeProcess(Message message) {
            return true;
        }
        
        /**
         * 处理后拦截
         * 
         * @param message 消息对象
         * @param result 处理结果
         */
        default void afterProcess(Message message, ProcessResult result) {}
    }
    
    /**
     * 消息过滤器接口
     */
    @FunctionalInterface
    interface MessageFilter {
        /**
         * 过滤消息
         * 
         * @param message 消息对象
         * @return 是否通过过滤
         */
        boolean filter(Message message);
    }
    
    /**
     * 处理结果
     */
    class ProcessResult {
        private final boolean success;
        private final String message;
        private final Throwable exception;
        
        public ProcessResult(boolean success, String message) {
            this.success = success;
            this.message = message;
            this.exception = null;
        }
        
        public ProcessResult(boolean success, String message, Throwable exception) {
            this.success = success;
            this.message = message;
            this.exception = exception;
        }
        
        public static ProcessResult success() {
            return new ProcessResult(true, "处理成功");
        }
        
        public static ProcessResult success(String message) {
            return new ProcessResult(true, message);
        }
        
        public static ProcessResult failure(String message) {
            return new ProcessResult(false, message);
        }
        
        public static ProcessResult failure(String message, Throwable exception) {
            return new ProcessResult(false, message, exception);
        }
        
        // Getters
        public boolean isSuccess() { return success; }
        public String getMessage() { return message; }
        public Throwable getException() { return exception; }
        
        @Override
        public String toString() {
            return String.format("ProcessResult{success=%s, message='%s'}", success, message);
        }
    }
    
    /**
     * 注册消息拦截器
     * 
     * @param interceptor 拦截器
     */
    default void registerInterceptor(MessageInterceptor interceptor) {
        // 默认空实现
    }
    
    /**
     * 移除消息拦截器
     * 
     * @param interceptor 拦截器
     */
    default void removeInterceptor(MessageInterceptor interceptor) {
        // 默认空实现
    }
    
    /**
     * 注册消息过滤器
     * 
     * @param filter 过滤器
     */
    default void registerFilter(MessageFilter filter) {
        // 默认空实现
    }
    
    /**
     * 移除消息过滤器
     * 
     * @param filter 过滤器
     */
    default void removeFilter(MessageFilter filter) {
        // 默认空实现
    }
}
